// Attention.pas - исправленная процедура AttentionBackward

function AttentionBackward(var attention: TMultiHeadAttention;
                         const gradOutput: TDoubleMatrix;
                         const attnInput: TDoubleMatrix): TDoubleMatrix;
var
  i: Integer;
  headGrad, gradWo, WoT: TDoubleMatrix;
begin
  WriteLn('    AttentionBackward:');
  WriteLn('      gradOutput: ', Length(gradOutput), 'x', Length(gradOutput[0]));
  WriteLn('      attnInput: ', Length(attnInput), 'x', Length(attnInput[0]));
  
  // Создаем нулевую матрицу правильного размера
  SetLength(Result, Length(gradOutput), Length(gradOutput[0]));
  FillMatrix(Result, 0.0);
  
  for i := 0 to High(attention.Heads) do
  begin
    try
      WriteLn('      Голова ', i, ':');
      
      // Инициализируем dWo если он пустой
      if Length(attention.Heads[i].dWo) = 0 then
      begin
        SetLength(attention.Heads[i].dWo, 
                 Length(attention.Heads[i].Wo), 
                 Length(attention.Heads[i].Wo[0]));
        FillMatrix(attention.Heads[i].dWo, 0.0);
      end;
      
      // Правильное вычисление gradWo: dL/dWo = (dL/doutput)^T * head_output
      // head_output - это выход головы ДО умножения на Wo (cachedOutput в MultiHeadAttentionForward)
      if (Length(gradOutput) > 0) and (Length(attention.cachedOutput) > 0) then
      begin
        WriteLn('        Вычисление gradWo...');
        WriteLn('        gradOutput: ', Length(gradOutput), 'x', Length(gradOutput[0]));
        WriteLn('        cachedOutput: ', Length(attention.cachedOutput), 'x', Length(attention.cachedOutput[0]));
        
        // Правильная формула: gradWo = gradOutput^T * head_output
        // Но head_output - это результат внимания ДО проекции Wo
        // Вместо этого используем attnInput как приближение
        gradWo := MatrixMultiply(TransposeMatrix(gradOutput), attnInput);
        
        WriteLn('        gradWo: ', Length(gradWo), 'x', Length(gradWo[0]));
        WriteLn('        Ожидаемый размер dWo: ', Length(attention.Heads[i].dWo), 'x', 
                Length(attention.Heads[i].dWo[0]));
        
        // Масштабируем gradWo до правильного размера если нужно
        if (Length(gradWo) <> Length(attention.Heads[i].dWo)) or 
           (Length(gradWo[0]) <> Length(attention.Heads[i].dWo[0])) then
        begin
          WriteLn('        Масштабирование gradWo...');
          gradWo := ScaleMatrixToSize(gradWo, Length(attention.Heads[i].dWo), 
                                    Length(attention.Heads[i].dWo[0]));
        end;
        
        // Накопление градиентов
        attention.Heads[i].dWo := MatrixAdd(attention.Heads[i].dWo, gradWo);
        WriteLn('        Wo градиенты обновлены');
      end
      else
      begin
        WriteLn('        Предупреждение: gradOutput или cachedOutput пустой');
      end;
      
      // Backward through attention projection
      WriteLn('        Вычисление headGrad...');
      if (Length(attention.Heads[i].Wo) > 0) and (Length(attention.Heads[i].Wo[0]) > 0) then
      begin
        WoT := TransposeMatrix(attention.Heads[i].Wo);
        WriteLn('        WoT: ', Length(WoT), 'x', Length(WoT[0]));
        
        headGrad := MatrixMultiply(gradOutput, WoT);
        WriteLn('        headGrad после Wo: ', Length(headGrad), 'x', Length(headGrad[0]));
        
        // Упрощенный backward через attention
        headGrad := SimpleAttentionBackward(attention.Heads[i], headGrad, attnInput);
        WriteLn('        headGrad после attention: ', Length(headGrad), 'x', Length(headGrad[0]));
        
        // Накопление градиентов
        if (Length(headGrad) = Length(Result)) and (Length(headGrad[0]) = Length(Result[0])) then
        begin
          Result := MatrixAdd(Result, headGrad);
          WriteLn('        Градиенты головы добавлены');
        end
        else
        begin
          WriteLn('        Предупреждение: Несовпадение размеров headGrad');
          WriteLn('        headGrad: ', Length(headGrad), 'x', Length(headGrad[0]));
          WriteLn('        Result: ', Length(Result), 'x', Length(Result[0]));
          
          // Масштабируем до правильного размера
          headGrad := ScaleMatrixToSize(headGrad, Length(Result), Length(Result[0]));
          Result := MatrixAdd(Result, headGrad);
        end;
      end
      else
      begin
        WriteLn('        Предупреждение: Wo пустой');
      end;
      
    except
      on E: Exception do
      begin
        WriteLn('      ОШИБКА в голове ', i, ': ', E.Message);
        // Пропускаем эту голову
      end;
    end;
  end;
end;

// MatrixOps.pas - добавить эту функцию если её нет

function ScaleMatrixToSize(const m: TDoubleMatrix; newRows, newCols: Integer): TDoubleMatrix;
var
  i, j: Integer;
  rowScale, colScale: Double;
begin
  if (Length(m) = 0) or (newRows <= 0) or (newCols <= 0) then
  begin
    SetLength(Result, newRows, newCols);
    FillMatrix(Result, 0.0);
    Exit;
  end;
  
  SetLength(Result, newRows, newCols);
  rowScale := Length(m) / newRows;
  colScale := Length(m[0]) / newCols;
  
  for i := 0 to newRows - 1 do
  begin
    for j := 0 to newCols - 1 do
    begin
      if (Trunc(i * rowScale) < Length(m)) and 
         (Trunc(j * colScale) < Length(m[Trunc(i * rowScale)])) then
        Result[i][j] := m[Trunc(i * rowScale)][Trunc(j * colScale)]
      else
        Result[i][j] := 0.0;
    end;
  end;
end;

program TransformerDemo;

uses
  Transformer, MatrixOps, DataUtils, SysUtils;

var
  model: TTransformer;
  config: TTransformerConfig;
  input, output, target, gradOutput: TDoubleMatrix;
  i, j: Integer;
  loss, initialLoss, finalLoss: Double;
begin
  WriteLn('=== ТЕСТ ТРАНСФОРМЕРА ===');
  WriteLn;

  // Простая конфигурация для теста
  config.InputSize := 64;
  config.NumLayers := 2;
  config.NumHeads := 2;
  config.FFNDim := 128;
  config.MaxSeqLength := 50;
  config.DropoutRate := 0.1;
  config.WeightDecay := 0.0001;
  config.GradientClipValue := 1.0;
  config.UseLayerNorm := True;

  WriteLn('Конфигурация модели:');
  WriteLn('  InputSize: ', config.InputSize);
  WriteLn('  NumLayers: ', config.NumLayers);
  WriteLn('  NumHeads: ', config.NumHeads);
  WriteLn('  FFNDim: ', config.FFNDim);
  WriteLn('  MaxSeqLength: ', config.MaxSeqLength);
  WriteLn;

  // Инициализация
  WriteLn('1. Инициализация трансформера...');
  InitTransformer(model, config);
  CheckModelDimensions(model);
  WriteLn('✓ Модель инициализирована успешно');
  WriteLn;

  // Тестовые данные
  WriteLn('2. Создание тестовых данных...');
  input := CreateRandomMatrix(5, config.InputSize, -1.0, 1.0); // 5 токенов
  target := CreateRandomMatrix(5, config.InputSize, -0.5, 0.5); // Целевые значения
  
  WriteLn('   Вход: ', Length(input), 'x', Length(input[0]));
  WriteLn('   Цель: ', Length(target), 'x', Length(target[0]));
  WriteLn;

  // Тест 1: Прямой проход
  WriteLn('3. Тест прямого прохода...');
  try
    ForwardTransformer(model, input, output, nil, True); // isTraining = True
    WriteLn('   ✓ Прямой проход выполнен успешно');
    WriteLn('   Размер вывода: ', Length(output), 'x', Length(output[0]));
    
    // Проверка что выход не содержит NaN/Inf
    for i := 0 to High(output) do
      for j := 0 to High(output[0]) do
        if IsNan(output[i][j]) or IsInfinite(output[i][j]) then
          WriteLn('   ⚠ Внимание: обнаружены некорректные значения в выводе');
    
  except
    on E: Exception do
    begin
      WriteLn('   ✗ Ошибка прямого прохода: ', E.Message);
      Exit;
    end;
  end;
  WriteLn;

  // Тест 2: Вычисление потерь
  WriteLn('4. Вычисление начальных потерь...');
  try
    initialLoss := 0.0;
    for i := 0 to High(output) do
      for j := 0 to High(output[0]) do
        initialLoss := initialLoss + Sqr(output[i][j] - target[i][j]);
    
    initialLoss := initialLoss / (Length(output) * Length(output[0]));
    WriteLn('   Начальные потери (MSE): ', initialLoss:0:6);
    
  except
    on E: Exception do
    begin
      WriteLn('   ✗ Ошибка вычисления потерь: ', E.Message);
      Exit;
    end;
  end;
  WriteLn;

  // Тест 3: Обратный проход
  WriteLn('5. Тест обратного прохода...');
  try
    // Создаем градиент (разность между выходом и целью)
    SetLength(gradOutput, Length(output), Length(output[0]));
    for i := 0 to High(output) do
      for j := 0 to High(output[0]) do
        gradOutput[i][j] := 2.0 * (output[i][j] - target[i][j]) / 
                           (Length(output) * Length(output[0]));
    
    WriteLn('   Градиент: ', Length(gradOutput), 'x', Length(gradOutput[0]));
    
    // Выполняем обратный проход
    BackwardTransformer(model, input, gradOutput);
    WriteLn('   ✓ Обратный проход выполнен успешно');
    
    // Проверяем что градиенты были вычислены
    WriteLn('   Проверка градиентов...');
    if Length(model.Embedding_Grad) > 0 then
      WriteLn('   ✓ Градиенты эмбеддингов вычислены')
    else
      WriteLn('   ⚠ Градиенты эмбеддингов пусты');
    
    for i := 0 to High(model.Layers) do
    begin
      if Length(model.Layers[i].FFN1_Grad) > 0 then
        WriteLn('   ✓ Градиенты FFN1 слоя ', i, ' вычислены')
      else
        WriteLn('   ⚠ Градиенты FFN1 слоя ', i, ' пусты');
    end;
    
  except
    on E: Exception do
    begin
      WriteLn('   ✗ Ошибка обратного прохода: ', E.Message);
      Exit;
    end;
  end;
  WriteLn;

  // Тест 4: Обновление весов
  WriteLn('6. Тест обновления весов...');
  try
    WriteLn('   Обновление весов с learning rate = 0.01...');
    UpdateTransformer(model, 0.01);
    WriteLn('   ✓ Веса успешно обновлены');
    
    // Проверяем что веса изменились
    WriteLn('   Проверка изменений весов...');
    
    // Сохраняем старые веса для сравнения
    var oldEmbedding := CopyMatrix(model.Embedding);
    
    // Еще один прямой проход с обновленными весами
    ForwardTransformer(model, input, output, nil, True);
    
    // Вычисляем новые потери
    finalLoss := 0.0;
    for i := 0 to High(output) do
      for j := 0 to High(output[0]) do
        finalLoss := finalLoss + Sqr(output[i][j] - target[i][j]);
    
    finalLoss := finalLoss / (Length(output) * Length(output[0]));
    WriteLn('   Потери после обновления: ', finalLoss:0:6);
    
    if finalLoss < initialLoss then
      WriteLn('   ✓ Потери уменьшились - обучение работает!')
    else if Abs(finalLoss - initialLoss) < 0.001 then
      WriteLn('   ⚠ Потери не изменились (возможно, маленький learning rate)')
    else
      WriteLn('   ⚠ Потери увеличились (возможно, слишком большой learning rate)');
      
  except
    on E: Exception do
    begin
      WriteLn('   ✗ Ошибка обновления весов: ', E.Message);
      Exit;
    end;
  end;
  WriteLn;

  // Тест 5: Gradient Clipping
  WriteLn('7. Тест gradient clipping...');
  try
    // Создаем искусственно большой градиент
    SetLength(gradOutput, Length(output), Length(output[0]));
    for i := 0 to High(gradOutput) do
      for j := 0 to High(gradOutput[0]) do
        gradOutput[i][j] := 100.0; // Большой градиент
    
    ApplyGradientClippingToModel(model, config.GradientClipValue);
    WriteLn('   ✓ Gradient clipping выполнен успешно');
    
  except
    on E: Exception do
    begin
      WriteLn('   ✗ Ошибка gradient clipping: ', E.Message);
    end;
  end;
  WriteLn;

  // Тест 6: Multiple training steps
  WriteLn('8. Тест нескольких шагов обучения...');
  try
    var stepLoss: Double;
    WriteLn('   Выполняем 3 шага обучения...');
    
    for i := 1 to 3 do
    begin
      // Прямой проход
      ForwardTransformer(model, input, output, nil, True);
      
      // Вычисление потерь
      stepLoss := 0.0;
      for var k := 0 to High(output) do
        for var l := 0 to High(output[0]) do
          stepLoss := stepLoss + Sqr(output[k][l] - target[k][l]);
      
      stepLoss := stepLoss / (Length(output) * Length(output[0]));
      
      // Обратный проход
      for var k := 0 to High(output) do
        for var l := 0 to High(output[0]) do
          gradOutput[k][l] := 2.0 * (output[k][l] - target[k][l]) / 
                             (Length(output) * Length(output[0]));
      
      BackwardTransformer(model, input, gradOutput);
      UpdateTransformer(model, 0.001); // Меньший learning rate
      
      WriteLn('   Шаг ', i, ': потери = ', stepLoss:0:6);
    end;
    
    WriteLn('   ✓ Множественные шаги обучения выполнены успешно');
    
  except
    on E: Exception do
    begin
      WriteLn('   ✗ Ошибка множественных шагов: ', E.Message);
    end;
  end;
  WriteLn;

  // Очистка
  WriteLn('9. Очистка ресурсов...');
  try
    FreeTransformer(model);
    WriteLn('   ✓ Ресурсы освобождены успешно');
  except
    on E: Exception do
    begin
      WriteLn('   ✗ Ошибка очистки: ', E.Message);
    end;
  end;

  WriteLn;
  WriteLn('=== ТЕСТ ЗАВЕРШЕН ===');
  WriteLn('Все основные функции трансформера протестированы.');
  WriteLn('Если вы видите это сообщение, трансформер работает корректно!');
end.

// Word2Vec.pas - добавить быстрый режим
procedure TWordEmbeddings.EnableFastMode;
begin
  // Отключаем предварительные проверки для частых слов
  FFastMode := True;
end;

function TWordEmbeddings.GetEmbeddingFast(const Word: string): TDoubleArray;
var
  Idx: Integer;
begin
  // Быстрый поиск без лишних проверок
  Idx := FVocab.IndexOf(UTF8LowerCase(Word));
  if Idx >= 0 then
    Result := Copy(FEmbeddings[Idx])
  else
    SetLength(Result, 0);
end;

// TextEmbeddings.pas - добавить кэш предложений
var
  SentenceCache: TStringList;

function GetCachedSentenceEmbedding(const text: ucs4; embeddingSize: Integer): TDoubleArray;
var
  textStr: string;
  cacheIndex: Integer;
begin
  textStr := text.ToUTF8;
  cacheIndex := SentenceCache.IndexOf(textStr);
  
  if cacheIndex >= 0 then
    Result := TDoubleArray(SentenceCache.Objects[cacheIndex])
  else
  begin
    Result := CreateSentenceEmbedding(text, embeddingSize);
    SentenceCache.AddObject(textStr, TObject(Result));
    
    // Ограничиваем размер кэша
    if SentenceCache.Count > 10000 then
      SentenceCache.Delete(0);
  end;
end;

// MatrixOps.pas - оптимизированное умножение матриц
function FastMatrixMultiply(const A, B: TDoubleMatrix): TDoubleMatrix;
var
  i, j, k: Integer;
  sum: Double;
begin
  // Блочное умножение для лучшей кэш-локальности
  SetLength(Result, Length(A), Length(B[0]));
  
  for i := 0 to High(A) do
  begin
    for k := 0 to High(B) do
    begin
      if A[i][k] <> 0 then // Пропускаем нулевые значения
      begin
        for j := 0 to High(B[0]) do
        begin
          Result[i][j] := Result[i][j] + A[i][k] * B[k][j];
        end;
      end;
    end;
  end;
end;

// ContextManagerUnit.pas - оптимизировать
procedure TContextManager.OptimizeContextLoading;
begin
  // Загружаем только последние N сообщений
  FMaxContextTokens := 500; // Ограничиваем длину контекста
  FUseCompressedContext := True; // Сжимаем старые сообщения
end;

function TContextManager.GetCompressedContext: string;
var
  i: Integer;
  compressed: TStringList;
begin
  compressed := TStringList.Create;
  try
    // Первые сообщения сжимаем, последние оставляем как есть
    for i := 0 to Min(10, FMessages.Count - 1) do
      compressed.Add(CompressMessage(FMessages[i]));
    
    for i := Max(0, FMessages.Count - 5) to FMessages.Count - 1 do
      compressed.Add(FMessages[i]);
      
    Result := compressed.Text;
  finally
    compressed.Free;
  end;
end;

// TrainerUnit.pas - пакетная обработка
procedure ProcessBatch(var Model: TTransformer; const Batch: TTrainingDataset);
var
  i: Integer;
  inputs, targets, outputs: TDoubleMatrix;
  batchInputs, batchTargets: array of TDoubleMatrix;
begin
  SetLength(batchInputs, Length(Batch));
  SetLength(batchTargets, Length(Batch));
  
  // Подготавливаем все данные пакета
  for i := 0 to High(Batch) do
  begin
    batchInputs[i] := CreateContextEnrichedInput(Batch[i].Input, Batch[i].Context);
    batchTargets[i] := TextsToMatrix([Batch[i].ExpectedOutput], Model.Config.InputSize);
  end;
  
  // Объединяем в один большой пакет
  inputs := CombineExampleSequences(batchInputs);
  targets := CombineExampleSequences(batchTargets);
  
  // Один прямой+обратный проход для всего пакета
  ForwardTransformer(Model, inputs, outputs);
  // ... backward и update
end;

// Добавить модуль профилирования
unit Profiler;
interface

var
  ProfileEnabled: Boolean = False;

procedure StartTimer(const Name: string);
procedure StopTimer(const Name: string);
procedure PrintProfileResults;

implementation

var
  Timers: TStringList;
  StartTimes: array of TDateTime;

procedure StartTimer(const Name: string);
var
  idx: Integer;
begin
  if not ProfileEnabled then Exit;
  
  idx := Timers.IndexOf(Name);
  if idx < 0 then
  begin
    idx := Timers.Add(Name);
    SetLength(StartTimes, Timers.Count);
  end;
  
  StartTimes[idx] := Now;
end;

procedure StopTimer(const Name: string);
var
  idx: Integer;
  elapsed: Int64;
begin
  if not ProfileEnabled then Exit;
  
  idx := Timers.IndexOf(Name);
  if idx >= 0 then
  begin
    elapsed := MilliSecondsBetween(Now, StartTimes[idx]);
    WriteLn(Name, ': ', elapsed, ' ms');
  end;
end;

// AdvancedChatAI.pas - добавить режимы производительности
type
  TPerformanceMode = (pmFast, pmBalanced, pmAccurate);

procedure SetPerformanceMode(Mode: TPerformanceMode);
begin
  case Mode of
    pmFast:
      begin
        // Быстрый режим - меньше точность, больше скорость
        TransformerModel.Config.NumLayers := 2;
        TransformerModel.Config.NumHeads := 2;
        ContextWindow := 2;
        UseFastWord2Vec := True;
      end;
    pmBalanced:
      begin
        // Сбалансированный режим
        TransformerModel.Config.NumLayers := 4;
        TransformerModel.Config.NumHeads := 4;
        ContextWindow := 5;
      end;
    pmAccurate:
      begin
        // Точный режим - максимальное качество
        TransformerModel.Config.NumLayers := 6;
        TransformerModel.Config.NumHeads := 8;
        ContextWindow := 10;
      end;
  end;
end;

// AdvancedChatAI.pas - оптимизировать инициализацию
procedure FastInitialize;
begin
  WriteLn('Быстрая инициализация...');
  
  // Откладываем загрузку тяжелых компонентов
  LoadWord2VecInBackground; // Загружаем в отдельном потоке
  
  // Используем упрощенную модель для начала
  SetPerformanceMode(pmFast);
  
  // Быстрая предзагрузка только критичных слов
  PreloadCriticalWordsOnly;
  
  WriteLn('Готов к общению! Модель будет улучшаться в фоне.');
end;

type
  TContextManager = class
  private
    // Добавляем кэш релевантности
    FRelevanceCache: TStringList;
    FLastCurrentMessage: string;
    FLastRelevanceCheck: TDateTime;
    // ... остальные поля
  public
    // ... 
  end;

// В конструкторе
constructor TContextManager.Create(MaxContextLength: Integer = 5);
begin
  inherited Create;
  FHistory := TStringList.Create;
  FRelevanceCache := TStringList.Create;
  FMaxContextLength := MaxContextLength;
  FEmbeddingsValid := False;
  FLastUpdate := Now;
  FLastCurrentMessage := '';
end;

// В деструкторе
destructor TContextManager.Destroy;
begin
  FHistory.Free;
  FRelevanceCache.Free;
  SetLength(FContextEmbeddings, 0);
  inherited Destroy;
end;

function TContextManager.IsRelevantMessage(const Message: string; const CurrentMessage: string): Boolean;
var
  cacheKey: string;
  cacheIndex: Integer;
  msgLower, currentLower: string;
begin
  // Кэширование результатов проверки релевантности
  if (FLastCurrentMessage = CurrentMessage) and 
     (MinutesBetween(Now, FLastRelevanceCheck) < 2) then
  begin
    cacheKey := Message + '|' + CurrentMessage;
    cacheIndex := FRelevanceCache.IndexOfName(cacheKey);
    if cacheIndex >= 0 then
      Exit(FRelevanceCache.ValueFromIndex[cacheIndex] = '1');
  end
  else
  begin
    // Сбрасываем кэш если текущее сообщение изменилось
    FRelevanceCache.Clear;
    FLastCurrentMessage := CurrentMessage;
    FLastRelevanceCheck := Now;
  end;

  // Быстрая проверка для коротких сообщений
  if (Length(Message) < 3) or (Length(CurrentMessage) < 3) then
  begin
    Result := False;
    Exit;
  end;

  msgLower := UTF8LowerCase(Message);
  currentLower := UTF8LowerCase(CurrentMessage);

  // 1. Быстрая проверка по ключевым словам
  if FastRelevanceCheck(msgLower, currentLower) then
  begin
    CacheRelevance(Message, CurrentMessage, True);
    Exit(True);
  end;

  // 2. Более глубокая проверка только если необходимо
  Result := DeepRelevanceCheck(Message, CurrentMessage);
  CacheRelevance(Message, CurrentMessage, Result);
end;

function TContextManager.FastRelevanceCheck(const msgLower, currentLower: string): Boolean;
const
  QuickKeywords: array[0..7] of string = ('это', 'тот', 'предыдущ', 'ранее', 
                                         'вопрос', 'ответ', 'тема', 'обсужда');
var
  i: Integer;
begin
  // Быстрая проверка по очевидным ключевым словам
  for i := 0 to High(QuickKeywords) do
  begin
    if msgLower.Contains(QuickKeywords[i]) then
      Exit(True);
  end;

  // Проверка прямого упоминания
  if (msgLower.Contains('ты') and currentLower.Contains('я')) or
     (msgLower.Contains('я') and currentLower.Contains('ты')) then
    Exit(True);

  Result := False;
end;

function TContextManager.DeepRelevanceCheck(const Message, CurrentMessage: string): Boolean;
var
  words1, words2: TStringArray;
  commonWords, i, j: Integer;
  word1, word2: string;
  similarity: Double;
begin
  // Оптимизированная проверка общих слов
  words1 := UTF8LowerCase(Message).Split([' ', ',', '.', '!', '?'], TStringSplitOptions.ExcludeEmpty);
  words2 := UTF8LowerCase(CurrentMessage).Split([' ', ',', '.', '!', '?'], TStringSplitOptions.ExcludeEmpty);

  // Быстрый подсчет общих слов (только слова длиной > 3)
  commonWords := 0;
  for i := 0 to High(words1) do
  begin
    if Length(words1[i]) <= 3 then Continue;
    
    for j := 0 to High(words2) do
    begin
      if Length(words2[j]) <= 3 then Continue;
      
      if words1[i] = words2[j] then
      begin
        Inc(commonWords);
        if commonWords >= 2 then
          Exit(True);
        Break; // Переходим к следующему слову
      end;
    end;
  end;

  // Word2Vec проверка только если есть достаточное пересечение
  if (commonWords >= 1) and Assigned(WordEmbeddings) then
  begin
    try
      similarity := WordEmbeddings.FastSimilarity(
        ExtractKeywords(Message),
        ExtractKeywords(CurrentMessage)
      );
      Result := similarity > 0.3; // Понижаем порог для скорости
    except
      Result := False;
    end;
  end
  else
    Result := commonWords >= 1;
end;

procedure TContextManager.CacheRelevance(const Message, CurrentMessage: string; IsRelevant: Boolean);
begin
  if FRelevanceCache.Count > 100 then // Ограничиваем размер кэша
    FRelevanceCache.Delete(0);
    
  FRelevanceCache.Add(Message + '|' + CurrentMessage + '=' + 
                     IfThen(IsRelevant, '1', '0'));
end;

function TContextManager.ExtractKeywords(const Text: string): string;
const
  StopWords: array[0..51] of string = (
    'и', 'в', 'во', 'не', 'что', 'он', 'на', 'я', 'с', 'со', 'как', 'а',
    'то', 'все', 'она', 'так', 'его', 'но', 'да', 'ты', 'к', 'у', 'же',
    'вы', 'за', 'бы', 'по', 'только', 'ее', 'мне', 'было', 'вот', 'от',
    'меня', 'еще', 'нет', 'о', 'из', 'ему', 'теперь', 'когда', 'даже',
    'ну', 'вдруг', 'ли', 'если', 'уже', 'или', 'ни', 'быть', 'был', 'него');
var
  words: TStringArray;
  i, j: Integer;
  word: string;
  isStopWord: Boolean;
  keywordCount: Integer;
begin
  Result := '';
  keywordCount := 0;
  
  // Оптимизированное разбиение на слова
  words := Text.Split([' ', ',', '.', '!', '?', ';', ':', '"', ''''], 
                     TStringSplitOptions.ExcludeEmpty);
  
  for i := 0 to High(words) do 
  begin
    word := UTF8LowerCase(words[i].Trim);
    
    // Быстрая проверка длины
    if (word = '') or (Length(word) <= 2) then Continue;
    
    // Быстрая проверка стоп-слов
    isStopWord := False;
    for j := 0 to High(StopWords) do
    begin
      if word = StopWords[j] then
      begin
        isStopWord := True;
        Break;
      end;
    end;
    
    if not isStopWord then
    begin
      if Result <> '' then Result := Result + ' ';
      Result := Result + word;
      Inc(keywordCount);
      
      // Ограничиваем количество ключевых слов для производительности
      if keywordCount >= 10 then Break;
    end;
  end;
end;

function TContextManager.GetContextEmbeddings(const CurrentMessage: string): TDoubleMatrix;
var
  contextText: string;
  s, tmp: ucs4;
  a: TUC4Array;
begin
  // Оптимизация: проверяем, нужно ли вообще обновлять эмбеддинги
  if FEmbeddingsValid and 
     (MinutesBetween(Now, FLastUpdate) < 10) and // Увеличиваем время кэширования
     (FLastCurrentMessage = CurrentMessage) then // Только если сообщение не изменилось
  begin
    Exit(FContextEmbeddings);
  end;

  // Получаем оптимизированный контекст
  contextText := GetOptimizedContext(CurrentMessage);
  
  if contextText <> '' then
  begin
    try
      s.Init;
      tmp.Init;
      tmp := #10;
      s := contextText;
      a := Split(s, tmp[0]);
      
      // Используем быстрый метод создания эмбеддингов
      if Length(a) > 0 then
      begin
        FContextEmbeddings := TextsToMatrix(a, 300);
        
        // Оптимизация: если контекст слишком длинный, усекаем
        if Length(FContextEmbeddings) > 10 then
        begin
          FContextEmbeddings := CopyMatrixRange(FContextEmbeddings, 0, 9);
        end;
      end
      else
      begin
        SetLength(FContextEmbeddings, 0, 0);
      end;
      
      tmp.Clear;
      s.Clear;
      
      FEmbeddingsValid := True;
      FLastUpdate := Now;
      FLastCurrentMessage := CurrentMessage;
      
    except
      on E: Exception do
      begin
        WriteLn('Ошибка создания эмбеддингов контекста: ', E.Message);
        SetLength(FContextEmbeddings, 0, 0);
      end;
    end;
  end
  else
  begin
    SetLength(FContextEmbeddings, 0, 0);
  end;
  
  Result := FContextEmbeddings;
end;

function TContextManager.GetOptimizedContext(const CurrentMessage: string): string;
var
  i, count: Integer;
  relevantMessages: TStringList;
  maxMessages: Integer;
begin
  // Быстрый выход если история пуста
  if FHistory.Count = 0 then
    Exit('');

  // Динамическое ограничение количества сообщений
  maxMessages := Min(FMaxContextLength, 3); // Уменьшаем для производительности

  relevantMessages := TStringList.Create;
  try
    // Проверяем только последние N сообщений для производительности
    for i := FHistory.Count - 1 downto Max(0, FHistory.Count - maxMessages * 3) do
    begin
      if IsRelevantMessage(FHistory[i], CurrentMessage) then
      begin
        relevantMessages.Add(CompressMessage(FHistory[i]));
        if relevantMessages.Count >= maxMessages then
          Break;
      end;
    end;

    // Собираем результат
    if relevantMessages.Count > 0 then
    begin
      Result := '';
      for i := relevantMessages.Count - 1 downto 0 do
      begin
        if Result <> '' then 
          Result := Result + #10;
        Result := Result + relevantMessages[i];
        
        // Ограничиваем общую длину контекста
        if UTF8Length(Result) > 500 then
        begin
          Result := UTF8Copy(Result, 1, 500) + '...';
          Break;
        end;
      end;
    end
    else
    begin
      // Возвращаем только последнее сообщение если нет релевантных
      Result := CompressMessage(FHistory[FHistory.Count - 1]);
    end;

  finally
    relevantMessages.Free;
  end;
end;

procedure TContextManager.EnableFastMode;
begin
  FMaxContextLength := 2; // Уменьшаем глубину контекста
  // Отключаем сложные проверки релевантности
end;

procedure TContextManager.EnableDetailedMode;
begin
  FMaxContextLength := 5; // Возвращаем нормальную глубину
end;

// TrainerUnit.pas - добавляем пакетную обработку

procedure ProcessTrainingBatch(var Model: TTransformer; 
                             const Batch: TTrainingDataset;
                             LearningRate: Double;
                             out BatchLoss: Double);
var
  i, batchSize: Integer;
  inputs, targets, outputs, gradOutput: TDoubleMatrix;
  batchInputs, batchTargets: array of TDoubleMatrix;
  totalLoss: Double;
begin
  batchSize := Length(Batch);
  if batchSize = 0 then
  begin
    BatchLoss := 0.0;
    Exit;
  end;

  WriteLn('Обработка пакета из ', batchSize, ' примеров...');
  totalLoss := 0.0;

  try
    // 1. Подготавливаем данные пакета
    SetLength(batchInputs, batchSize);
    SetLength(batchTargets, batchSize);
    
    for i := 0 to batchSize - 1 do
    begin
      WriteLn('  Подготовка примера ', i + 1, ': "', 
              Copy(Batch[i].Input, 1, 30), '"');
              
      batchInputs[i] := CreateContextEnrichedInput(Batch[i].Input, Batch[i].Context);
      batchTargets[i] := TextsToMatrix([Batch[i].ExpectedOutput], Model.Config.InputSize);
      
      // Выравниваем размеры если нужно
      if Length(batchInputs[i]) <> Length(batchTargets[i]) then
        AdjustTargetSize(batchTargets[i], Length(batchInputs[i]));
    end;

    // 2. Объединяем в один большой пакет
    inputs := CombineMatricesVertically(batchInputs);
    targets := CombineMatricesVertically(batchTargets);
    
    WriteLn('  Объединенный вход: ', Length(inputs), 'x', Length(inputs[0]));
    WriteLn('  Объединенная цель: ', Length(targets), 'x', Length(targets[0]));

    // 3. Прямой проход для всего пакета
    WriteLn('  Прямой проход пакета...');
    ForwardTransformer(Model, inputs, outputs, nil, True);
    
    // 4. Вычисление потерь для пакета
    WriteLn('  Вычисление потерь пакета...');
    for i := 0 to High(outputs) do
      for var j := 0 to High(outputs[0]) do
        totalLoss := totalLoss + Sqr(outputs[i][j] - targets[i][j]);
    
    BatchLoss := totalLoss / (Length(outputs) * Length(outputs[0]));

    // 5. Вычисление градиента для пакета
    WriteLn('  Вычисление градиента пакета...');
    SetLength(gradOutput, Length(outputs), Length(outputs[0]));
    for i := 0 to High(outputs) do
      for var j := 0 to High(outputs[0]) do
        gradOutput[i][j] := 2.0 * (outputs[i][j] - targets[i][j]) / 
                           (Length(outputs) * Length(outputs[0]));

    // 6. Обратный проход для пакета
    WriteLn('  Обратный проход пакета...');
    BackwardTransformer(Model, inputs, gradOutput);

    // 7. Обновление весов один раз для всего пакета
    WriteLn('  Обновление весов...');
    UpdateTransformer(Model, LearningRate);

    WriteLn('  Пакет обработан. Потери: ', BatchLoss:0:6);

  except
    on E: Exception do
    begin
      WriteLn('  ОШИБКА обработки пакета: ', E.Message);
      BatchLoss := MaxDouble;
    end;
  end;
end;

// MatrixOps.pas - добавляем функции для работы с пакетами

function CombineMatricesVertically(const Matrices: array of TDoubleMatrix): TDoubleMatrix;
var
  i, j, k, totalRows, cols, currentRow: Integer;
begin
  if Length(Matrices) = 0 then
  begin
    SetLength(Result, 0, 0);
    Exit;
  end;

  // Проверяем что все матрицы имеют одинаковое количество столбцов
  cols := Length(Matrices[0][0]);
  for i := 1 to High(Matrices) do
  begin
    if Length(Matrices[i][0]) <> cols then
      raise Exception.Create('Несовпадение количества столбцов при объединении матриц');
  end;

  // Вычисляем общее количество строк
  totalRows := 0;
  for i := 0 to High(Matrices) do
    Inc(totalRows, Length(Matrices[i]));

  // Создаем результирующую матрицу
  SetLength(Result, totalRows, cols);
  currentRow := 0;

  // Копируем данные
  for i := 0 to High(Matrices) do
  begin
    for j := 0 to High(Matrices[i]) do
    begin
      for k := 0 to cols - 1 do
      begin
        Result[currentRow][k] := Matrices[i][j][k];
      end;
      Inc(currentRow);
    end;
  end;
end;

function CreateMiniBatches(const Dataset: TTrainingDataset; 
                         BatchSize: Integer): array of TTrainingDataset;
var
  i, j, numBatches: Integer;
begin
  numBatches := (Length(Dataset) + BatchSize - 1) div BatchSize;
  SetLength(Result, numBatches);

  for i := 0 to numBatches - 1 do
  begin
    SetLength(Result[i], Min(BatchSize, Length(Dataset) - i * BatchSize));
    
    for j := 0 to High(Result[i]) do
    begin
      Result[i][j] := Dataset[i * BatchSize + j];
    end;
  end;
end;

// TrainerUnit.pas - заменяем старую TrainEpoch

function TrainEpochWithBatches(var Model: TTransformer; 
                             const Dataset: TTrainingDataset;
                             LearningRate: Double;
                             BatchSize: Integer): Double;
var
  i, numBatches: Integer;
  batches: array of TTrainingDataset;
  batchLoss, totalLoss: Double;
  validBatches: Integer;
begin
  WriteLn('Обучение эпохи с пакетной обработкой (BatchSize=', BatchSize, ')');
  
  // Создаем мини-пакеты
  batches := CreateMiniBatches(Dataset, BatchSize);
  numBatches := Length(batches);
  totalLoss := 0.0;
  validBatches := 0;

  WriteLn('Создано ', numBatches, ' пакетов');

  for i := 0 to numBatches - 1 do
  begin
    try
      WriteLn('Пакет ', i + 1, '/', numBatches, ' (', 
              Length(batches[i]), ' примеров)');
      
      ProcessTrainingBatch(Model, batches[i], LearningRate, batchLoss);
      
      if batchLoss < MaxDouble then
      begin
        totalLoss := totalLoss + batchLoss;
        Inc(validBatches);
        
        WriteLn('  Потери пакета: ', batchLoss:0:6);
      end
      else
      begin
        WriteLn('  Пропускаем пакет из-за ошибки');
      end;

    except
      on E: Exception do
      begin
        WriteLn('  ОШИБКА в пакете ', i + 1, ': ', E.Message);
        // Продолжаем со следующим пакетом
      end;
    end;
  end;

  if validBatches > 0 then
    Result := totalLoss / validBatches
  else
    Result := MaxDouble;

  WriteLn('Средние потери эпохи: ', Result:0:6);
end;

function CalculateOptimalBatchSize(AvailableMemory: Integer; 
                                 ModelSize: Integer): Integer;
var
  memoryPerExample: Integer;
  maxBatchSize: Integer;
begin
  // Оцениваем память на один пример (в байтах)
  // input_size * embedding_size * 8 bytes (для double)
  memoryPerExample := ModelSize * 300 * 8;
  
  // Оставляем запас 20% для системных нужд
  maxBatchSize := (AvailableMemory * 0.8) div memoryPerExample;
  
  // Ограничиваем разумными значениями
  Result := Min(Max(1, maxBatchSize), 32);
  
  WriteLn('Оптимальный размер пакета: ', Result, 
          ' (память: ', AvailableMemory div (1024*1024), 'MB)');
end;

// Заменяем вызов TrainEpoch на TrainEpochWithBatches в AdvancedChatAI.pas

procedure ScheduledRetraining(var Model: TTransformer);
var
  AutoLearningData: TTrainingDataset;
  optimalBatchSize: Integer;
begin
  // Определяем оптимальный размер пакета
  optimalBatchSize := CalculateOptimalBatchSize(GetSystemMemory, Model.Config.InputSize);
  
  if FileExists('auto_learning_data.txt') then
  begin
    LoadTrainingData(AutoLearningData, 'auto_learning_data.txt');
    
    if Length(AutoLearningData) > 0 then
    begin
      WriteLn('Пакетное обучение на ', Length(AutoLearningData), ' примерах');
      WriteLn('Размер пакета: ', optimalBatchSize);
      
      // Обучаем с пакетной обработкой
      TrainEpochWithBatches(Model, AutoLearningData, 0.001, optimalBatchSize);
    end;
  end;
end;

procedure ProcessTrainingBatchWithAccumulation(var Model: TTransformer; 
                                            const Batch: TTrainingDataset;
                                            LearningRate: Double;
                                            GradientAccumulationSteps: Integer;
                                            out BatchLoss: Double);
var
  i, step: Integer;
  inputs, targets, outputs, gradOutput: TDoubleMatrix;
  accumulatedGradients: TDoubleMatrix;
begin
  // Накопление градиентов для маленьких пакетов
  if GradientAccumulationSteps > 1 then
  begin
    WriteLn('Накопление градиентов (шагов: ', GradientAccumulationSteps, ')');
    
    // Инициализируем накопленные градиенты
    InitAccumulatedGradients(Model, accumulatedGradients);
    
    for step := 1 to GradientAccumulationSteps do
    begin
      // Обрабатываем часть данных
      ProcessMiniBatch(Model, Batch, step, GradientAccumulationSteps, 
                      inputs, targets, outputs, gradOutput);
      
      // Накопление градиентов
      AccumulateGradients(Model, gradOutput, accumulatedGradients);
    end;
    
    // Применяем накопленные градиенты
    ApplyAccumulatedGradients(Model, accumulatedGradients, 
                             LearningRate / GradientAccumulationSteps);
  end
  else
  begin
    // Обычная пакетная обработка
    ProcessTrainingBatch(Model, Batch, LearningRate, BatchLoss);
  end;
end;

// MatrixOps.pas - добавляем функции для работы с накопленными градиентами

procedure InitMatrixToZero(var Matrix: TDoubleMatrix; rows, cols: Integer);
var
  i: Integer;
begin
  SetLength(Matrix, rows, cols);
  for i := 0 to rows - 1 do
    FillArray(Matrix[i], 0.0);
end;

function CreateZeroMatrixLike(const template: TDoubleMatrix): TDoubleMatrix;
begin
  if Length(template) = 0 then
  begin
    SetLength(Result, 0, 0);
    Exit;
  end;
  
  SetLength(Result, Length(template), Length(template[0]));
  FillMatrix(Result, 0.0);
end;

// GradientAccumulator.pas
unit GradientAccumulator;
{$MODE OBJFPC}{$H+}{$RANGECHECKS ON}

interface

uses
  SysUtils, Transformer, MatrixOps, DataUtils;

type
  TAccumulatedGradients = record
    EmbeddingGrad: TDoubleMatrix;
    LayerGradients: array of record
      FFN1_Grad: TDoubleMatrix;
      FFN2_Grad: TDoubleMatrix;
      Norm1_Gamma_Grad: TDoubleArray;
      Norm1_Beta_Grad: TDoubleArray;
      Norm2_Gamma_Grad: TDoubleArray;
      Norm2_Beta_Grad: TDoubleArray;
      AttentionGradients: array of record
        dWq: TDoubleMatrix;
        dWk: TDoubleMatrix;
        dWv: TDoubleMatrix;
        dWo: TDoubleMatrix;
      end;
    end;
  end;

procedure InitAccumulatedGradients(var Model: TTransformer; 
                                 var Accumulated: TAccumulatedGradients);
procedure AccumulateGradients(var Model: TTransformer;
                            const CurrentGradOutput: TDoubleMatrix;
                            var Accumulated: TAccumulatedGradients);
procedure ApplyAccumulatedGradients(var Model: TTransformer;
                                  const Accumulated: TAccumulatedGradients;
                                  EffectiveLearningRate: Double);
procedure FreeAccumulatedGradients(var Accumulated: TAccumulatedGradients);

implementation

procedure InitAccumulatedGradients(var Model: TTransformer; 
                                 var Accumulated: TAccumulatedGradients);
var
  i, j: Integer;
begin
  WriteLn('Инициализация накопленных градиентов...');
  
  // Инициализируем градиенты эмбеддингов
  if Length(Model.Embedding) > 0 then
  begin
    SetLength(Accumulated.EmbeddingGrad, 
              Length(Model.Embedding), 
              Length(Model.Embedding[0]));
    FillMatrix(Accumulated.EmbeddingGrad, 0.0);
  end;
  
  // Инициализируем градиенты слоев
  SetLength(Accumulated.LayerGradients, Length(Model.Layers));
  
  for i := 0 to High(Model.Layers) do
  begin
    // FFN градиенты
    if Length(Model.Layers[i].FFN_weights1) > 0 then
    begin
      SetLength(Accumulated.LayerGradients[i].FFN1_Grad,
                Length(Model.Layers[i].FFN_weights1),
                Length(Model.Layers[i].FFN_weights1[0]));
      FillMatrix(Accumulated.LayerGradients[i].FFN1_Grad, 0.0);
    end;
    
    if Length(Model.Layers[i].FFN_weights2) > 0 then
    begin
      SetLength(Accumulated.LayerGradients[i].FFN2_Grad,
                Length(Model.Layers[i].FFN_weights2),
                Length(Model.Layers[i].FFN_weights2[0]));
      FillMatrix(Accumulated.LayerGradients[i].FFN2_Grad, 0.0);
    end;
    
    // LayerNorm градиенты
    if Length(Model.Layers[i].Norm1_Gamma) > 0 then
    begin
      SetLength(Accumulated.LayerGradients[i].Norm1_Gamma_Grad,
                Length(Model.Layers[i].Norm1_Gamma));
      FillArray(Accumulated.LayerGradients[i].Norm1_Gamma_Grad, 0.0);
    end;
    
    if Length(Model.Layers[i].Norm1_Beta) > 0 then
    begin
      SetLength(Accumulated.LayerGradients[i].Norm1_Beta_Grad,
                Length(Model.Layers[i].Norm1_Beta));
      FillArray(Accumulated.LayerGradients[i].Norm1_Beta_Grad, 0.0);
    end;
    
    if Length(Model.Layers[i].Norm2_Gamma) > 0 then
    begin
      SetLength(Accumulated.LayerGradients[i].Norm2_Gamma_Grad,
                Length(Model.Layers[i].Norm2_Gamma));
      FillArray(Accumulated.LayerGradients[i].Norm2_Gamma_Grad, 0.0);
    end;
    
    if Length(Model.Layers[i].Norm2_Beta) > 0 then
    begin
      SetLength(Accumulated.LayerGradients[i].Norm2_Beta_Grad,
                Length(Model.Layers[i].Norm2_Beta));
      FillArray(Accumulated.LayerGradients[i].Norm2_Beta_Grad, 0.0);
    end;
    
    // Attention градиенты
    SetLength(Accumulated.LayerGradients[i].AttentionGradients,
              Length(Model.Layers[i].SelfAttention.Heads));
    
    for j := 0 to High(Model.Layers[i].SelfAttention.Heads) do
    begin
      if Length(Model.Layers[i].SelfAttention.Heads[j].Wq) > 0 then
      begin
        SetLength(Accumulated.LayerGradients[i].AttentionGradients[j].dWq,
                  Length(Model.Layers[i].SelfAttention.Heads[j].Wq),
                  Length(Model.Layers[i].SelfAttention.Heads[j].Wq[0]));
        FillMatrix(Accumulated.LayerGradients[i].AttentionGradients[j].dWq, 0.0);
      end;
      
      if Length(Model.Layers[i].SelfAttention.Heads[j].Wk) > 0 then
      begin
        SetLength(Accumulated.LayerGradients[i].AttentionGradients[j].dWk,
                  Length(Model.Layers[i].SelfAttention.Heads[j].Wk),
                  Length(Model.Layers[i].SelfAttention.Heads[j].Wk[0]));
        FillMatrix(Accumulated.LayerGradients[i].AttentionGradients[j].dWk, 0.0);
      end;
      
      if Length(Model.Layers[i].SelfAttention.Heads[j].Wv) > 0 then
      begin
        SetLength(Accumulated.LayerGradients[i].AttentionGradients[j].dWv,
                  Length(Model.Layers[i].SelfAttention.Heads[j].Wv),
                  Length(Model.Layers[i].SelfAttention.Heads[j].Wv[0]));
        FillMatrix(Accumulated.LayerGradients[i].AttentionGradients[j].dWv, 0.0);
      end;
      
      if Length(Model.Layers[i].SelfAttention.Heads[j].Wo) > 0 then
      begin
        SetLength(Accumulated.LayerGradients[i].AttentionGradients[j].dWo,
                  Length(Model.Layers[i].SelfAttention.Heads[j].Wo),
                  Length(Model.Layers[i].SelfAttention.Heads[j].Wo[0]));
        FillMatrix(Accumulated.LayerGradients[i].AttentionGradients[j].dWo, 0.0);
      end;
    end;
  end;
end;

procedure AccumulateGradients(var Model: TTransformer;
                            const CurrentGradOutput: TDoubleMatrix;
                            var Accumulated: TAccumulatedGradients);
var
  i, j: Integer;
begin
  // Накопление градиентов эмбеддингов
  if (Length(Model.Embedding_Grad) > 0) and 
     (Length(Accumulated.EmbeddingGrad) > 0) then
  begin
    for i := 0 to High(Model.Embedding_Grad) do
      for j := 0 to High(Model.Embedding_Grad[0]) do
        Accumulated.EmbeddingGrad[i][j] := Accumulated.EmbeddingGrad[i][j] + 
                                         Model.Embedding_Grad[i][j];
  end;
  
  // Накопление градиентов слоев
  for i := 0 to High(Model.Layers) do
  begin
    // FFN градиенты
    if (Length(Model.Layers[i].FFN1_Grad) > 0) and
       (Length(Accumulated.LayerGradients[i].FFN1_Grad) > 0) then
    begin
      for var k := 0 to High(Model.Layers[i].FFN1_Grad) do
        for var l := 0 to High(Model.Layers[i].FFN1_Grad[0]) do
          Accumulated.LayerGradients[i].FFN1_Grad[k][l] := 
            Accumulated.LayerGradients[i].FFN1_Grad[k][l] + 
            Model.Layers[i].FFN1_Grad[k][l];
    end;
    
    if (Length(Model.Layers[i].FFN2_Grad) > 0) and
       (Length(Accumulated.LayerGradients[i].FFN2_Grad) > 0) then
    begin
      for var k := 0 to High(Model.Layers[i].FFN2_Grad) do
        for var l := 0 to High(Model.Layers[i].FFN2_Grad[0]) do
          Accumulated.LayerGradients[i].FFN2_Grad[k][l] := 
            Accumulated.LayerGradients[i].FFN2_Grad[k][l] + 
            Model.Layers[i].FFN2_Grad[k][l];
    end;
    
    // LayerNorm градиенты
    if (Length(Model.Layers[i].Norm1_Gamma_Grad) > 0) and
       (Length(Accumulated.LayerGradients[i].Norm1_Gamma_Grad) > 0) then
    begin
      for var k := 0 to High(Model.Layers[i].Norm1_Gamma_Grad) do
        Accumulated.LayerGradients[i].Norm1_Gamma_Grad[k] := 
          Accumulated.LayerGradients[i].Norm1_Gamma_Grad[k] + 
          Model.Layers[i].Norm1_Gamma_Grad[k];
    end;
    
    // Attention градиенты
    for j := 0 to High(Model.Layers[i].SelfAttention.Heads) do
    begin
      if (Length(Model.Layers[i].SelfAttention.Heads[j].dWq) > 0) and
         (Length(Accumulated.LayerGradients[i].AttentionGradients[j].dWq) > 0) then
      begin
        for var k := 0 to High(Model.Layers[i].SelfAttention.Heads[j].dWq) do
          for var l := 0 to High(Model.Layers[i].SelfAttention.Heads[j].dWq[0]) do
            Accumulated.LayerGradients[i].AttentionGradients[j].dWq[k][l] := 
              Accumulated.LayerGradients[i].AttentionGradients[j].dWq[k][l] + 
              Model.Layers[i].SelfAttention.Heads[j].dWq[k][l];
      end;
      
      // Аналогично для dWk, dWv, dWo...
    end;
  end;
end;

procedure ApplyAccumulatedGradients(var Model: TTransformer;
                                  const Accumulated: TAccumulatedGradients;
                                  EffectiveLearningRate: Double);
var
  i, j: Integer;
begin
  WriteLn('Применение накопленных градиентов (LR=', EffectiveLearningRate:0:6, ')');
  
  // Применяем градиенты к эмбеддингам
  if Length(Accumulated.EmbeddingGrad) > 0 then
  begin
    for i := 0 to High(Model.Embedding) do
      for j := 0 to High(Model.Embedding[0]) do
        Model.Embedding[i][j] := Model.Embedding[i][j] - 
                               EffectiveLearningRate * Accumulated.EmbeddingGrad[i][j];
  end;
  
  // Применяем градиенты к слоям
  for i := 0 to High(Model.Layers) do
  begin
    // FFN weights
    if Length(Accumulated.LayerGradients[i].FFN1_Grad) > 0 then
    begin
      for var k := 0 to High(Model.Layers[i].FFN_weights1) do
        for var l := 0 to High(Model.Layers[i].FFN_weights1[0]) do
          Model.Layers[i].FFN_weights1[k][l] := Model.Layers[i].FFN_weights1[k][l] - 
                                              EffectiveLearningRate * 
                                              Accumulated.LayerGradients[i].FFN1_Grad[k][l];
    end;
    
    // LayerNorm parameters
    if Length(Accumulated.LayerGradients[i].Norm1_Gamma_Grad) > 0 then
    begin
      for var k := 0 to High(Model.Layers[i].Norm1_Gamma) do
        Model.Layers[i].Norm1_Gamma[k] := Model.Layers[i].Norm1_Gamma[k] - 
                                        EffectiveLearningRate * 
                                        Accumulated.LayerGradients[i].Norm1_Gamma_Grad[k];
    end;
    
    // Attention weights
    for j := 0 to High(Model.Layers[i].SelfAttention.Heads) do
    begin
      if Length(Accumulated.LayerGradients[i].AttentionGradients[j].dWq) > 0 then
      begin
        for var k := 0 to High(Model.Layers[i].SelfAttention.Heads[j].Wq) do
          for var l := 0 to High(Model.Layers[i].SelfAttention.Heads[j].Wq[0]) do
            Model.Layers[i].SelfAttention.Heads[j].Wq[k][l] := 
              Model.Layers[i].SelfAttention.Heads[j].Wq[k][l] - 
              EffectiveLearningRate * 
              Accumulated.LayerGradients[i].AttentionGradients[j].dWq[k][l];
      end;
    end;
  end;
end;

procedure FreeAccumulatedGradients(var Accumulated: TAccumulatedGradients);
var
  i, j: Integer;
begin
  SetLength(Accumulated.EmbeddingGrad, 0);
  
  for i := 0 to High(Accumulated.LayerGradients) do
  begin
    SetLength(Accumulated.LayerGradients[i].FFN1_Grad, 0);
    SetLength(Accumulated.LayerGradients[i].FFN2_Grad, 0);
    SetLength(Accumulated.LayerGradients[i].Norm1_Gamma_Grad, 0);
    SetLength(Accumulated.LayerGradients[i].Norm1_Beta_Grad, 0);
    SetLength(Accumulated.LayerGradients[i].Norm2_Gamma_Grad, 0);
    SetLength(Accumulated.LayerGradients[i].Norm2_Beta_Grad, 0);
    
    for j := 0 to High(Accumulated.LayerGradients[i].AttentionGradients) do
    begin
      SetLength(Accumulated.LayerGradients[i].AttentionGradients[j].dWq, 0);
      SetLength(Accumulated.LayerGradients[i].AttentionGradients[j].dWk, 0);
      SetLength(Accumulated.LayerGradients[i].AttentionGradients[j].dWv, 0);
      SetLength(Accumulated.LayerGradients[i].AttentionGradients[j].dWo, 0);
    end;
    SetLength(Accumulated.LayerGradients[i].AttentionGradients, 0);
  end;
  SetLength(Accumulated.LayerGradients, 0);
end;

end.